#include "implementacionhash.h"
#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

//
implementacionHash::implementacionHash(  ) 
{
	this->archivosProcesar=("");
	this->idsAIndexar=("");
}
//

bool implementacionHash::yaExiste(string nombre){
	string linea="";
    ifstream archivo(pathHash.c_str());
    if(archivo){
     while(getline(archivo,linea,'\n')){
   	  if(this->obtenerNombreDeLinea(linea).compare(nombre)==0){
   	  	 archivo.close();
   	  	 return true;
   	  	 break;
  	  }
     }
     archivo.close();
     return false;   
   	}
   	return false;
}

void implementacionHash::agregarParaProcesamiento(string nombre){
	this->archivosProcesar += "|" + nombre;
}

void implementacionHash::agregarAIndexar(string id){
	this->idsAIndexar += "|" + id;
}

string implementacionHash::obtenerProximoArchivoAProcesar(){
	if(this->archivosProcesar.length()>0){
		string archivo=("");
		string::size_type posicionPrimerPipe = this->archivosProcesar.find("|",0);
		string::size_type posicionSegundoPipe = this->archivosProcesar.find("|",posicionPrimerPipe+1);
		archivo = this->archivosProcesar.substr(posicionPrimerPipe+1,(posicionSegundoPipe-posicionPrimerPipe)-1);
	    if(posicionSegundoPipe!= string::npos){
	    	this->archivosProcesar = this->archivosProcesar.substr((posicionSegundoPipe),(this->archivosProcesar.length()-posicionSegundoPipe)+1);
    	}
    	else{
    		this->archivosProcesar.erase();
   		}
   		return archivo;
	  }
    else{
		return "";
	}
}

string implementacionHash::obtenerProximoId(){
	if(this->idsAIndexar.length()>0){
		string id=("");
		string::size_type posicionPrimerPipe = this->idsAIndexar.find("|",0);
		string::size_type posicionSegundoPipe = this->idsAIndexar.find("|",posicionPrimerPipe+1);
		id = this->idsAIndexar.substr(posicionPrimerPipe+1,(posicionSegundoPipe-posicionPrimerPipe)-1);
	    if(posicionSegundoPipe!= string::npos){
	    	this->idsAIndexar = this->idsAIndexar.substr((posicionSegundoPipe),(this->idsAIndexar.length()-posicionSegundoPipe)+1);
    	}
    	else{
    		this->idsAIndexar.erase();
   		}
   		return id;
	  }
    else{
		return "";
	}
}

string implementacionHash::obtenerIdDeLinea(string linea){
	string::size_type pos;
	
	pos = linea.find("|",0);
	if(pos!=string::npos){
		return linea.substr(0,pos);
	}
	return "";
		
}

string implementacionHash::obtenerNombreDeLinea(string linea){
	string::size_type pos;
	
	pos = linea.find("|",0);
	if(pos!=string::npos){
		return linea.substr(pos+1,linea.length());
	}
	return "";
}

void implementacionHash::ingresarlinea(string id,string nombreArchivo){
	ofstream archivo(pathHash.c_str(),fstream::app | fstream::ate);
    if(archivo){
       	string linea(id +"|" + nombreArchivo + '\n');
        archivo << linea;
        archivo.flush();
        archivo.close(); 
    }
}

string implementacionHash::obtenerUltimoId(){
	string lineaLeida="";
	string linea="";
    ifstream archivo(pathHash.c_str());
    if(archivo){
         while(getline(archivo,lineaLeida,'\n')){
         	 if(lineaLeida.compare("")!=0){
         	 		linea=lineaLeida;
        	 	}
         }
         archivo.close(); 
         return this->obtenerIdDeLinea(linea);
    }
    return "";
}

FILE* implementacionHash::obtenerDocumentoHash(string idDocumento){
    string path = directorioTxtProcesados + "/'" + idDocumento + "'.txt";
	return fopen(path.c_str(),"r+");
}


string implementacionHash::obtenerIdHash(string nombreDocumento){
	if(!this->yaExiste(nombreDocumento)){
 	    string id = this->obtenerUltimoId();      
       	if(id.compare("")==0){
       		//esta vacio asique le asigno 0;
       		this->ingresarlinea("1",nombreDocumento);
       		return "1";
      	}
      	else{
      			int ident = atoi(id.c_str()) + 1;
      			string s;
				stringstream out;
				out << ident;
				s = out.str();
            	this->ingresarlinea(s,nombreDocumento);
            	return s;
     		}
	}
	else{
		string linea="";
        ifstream archivo(pathHash.c_str());
        if(archivo){
         while(getline(archivo,linea,'\n')){
         	  if(this->obtenerNombreDeLinea(linea).compare(nombreDocumento)==0){
         	  	 	break;
        	  	}
         }
         archivo.close(); 
         return this->obtenerIdDeLinea(linea);
       	}
       	 archivo.close(); 
       	return "";
	}
	return "";
}

string implementacionHash::obtenerNombreDocumento(string id){
	string linea="";
    ifstream archivo(pathHash.c_str());
    if(archivo){
     while(getline(archivo,linea,'\n')){
   	  if(this->obtenerIdDeLinea(linea).compare(id)==0){
   	  	 return this->obtenerNombreDeLinea(linea);
   	  	 break;
  	  }
     }
     return "";   
   	}
   	return "";
}

void implementacionHash::insertarDocumento(string nombreDocumento){
	agregarParaProcesamiento(nombreDocumento);
}

implementacionHash:: ~implementacionHash(){
	
}


